Termination w.r.t. Q proof of /tmp/tmpKPfADm/ExIntrod_Zan97

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
A__PROD(s(X), Y) → MARK(Y)
MARK(prod(X1, X2)) → A__PROD(mark(X1), mark(X2))
MARK(fact(X)) → MARK(X)
MARK(fact(X)) → A__FACT(mark(X))
MARK(zero(X)) → A__ZERO(mark(X))
MARK(add(X1, X2)) → MARK(X1)
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(p(X)) → MARK(X)
A__PROD(s(X), Y) → MARK(X)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(prod(X1, X2)) → MARK(X2)
MARK(p(X)) → A__P(mark(X))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__ADD(s(X), Y) → MARK(X)
A__P(s(X)) → MARK(X)
A__IF(true, X, Y) → MARK(X)
A__IF(false, X, Y) → MARK(Y)
MARK(if(X1, X2, X3)) → A__IF(mark(X1), X2, X3)
A__FACT(X) → A__ZERO(mark(X))
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))
MARK(zero(X)) → MARK(X)

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
A__PROD(s(X), Y) → MARK(Y)
MARK(prod(X1, X2)) → A__PROD(mark(X1), mark(X2))
MARK(fact(X)) → MARK(X)
MARK(fact(X)) → A__FACT(mark(X))
MARK(zero(X)) → A__ZERO(mark(X))
MARK(add(X1, X2)) → MARK(X1)
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(p(X)) → MARK(X)
A__PROD(s(X), Y) → MARK(X)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(prod(X1, X2)) → MARK(X2)
MARK(p(X)) → A__P(mark(X))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__ADD(s(X), Y) → MARK(X)
A__P(s(X)) → MARK(X)
A__IF(true, X, Y) → MARK(X)
A__IF(false, X, Y) → MARK(Y)
MARK(if(X1, X2, X3)) → A__IF(mark(X1), X2, X3)
A__FACT(X) → A__ZERO(mark(X))
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))
MARK(zero(X)) → MARK(X)

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(prod(X1, X2)) → A__PROD(mark(X1), mark(X2))
MARK(add(X1, X2)) → MARK(X2)
A__PROD(s(X), Y) → MARK(Y)
MARK(fact(X)) → MARK(X)
MARK(fact(X)) → A__FACT(mark(X))
MARK(add(X1, X2)) → MARK(X1)
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(p(X)) → MARK(X)
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(X)) → A__P(mark(X))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
A__IF(true, X, Y) → MARK(X)
A__IF(false, X, Y) → MARK(Y)
MARK(if(X1, X2, X3)) → A__IF(mark(X1), X2, X3)
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))
MARK(zero(X)) → MARK(X)

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(if(X1, X2, X3)) → A__IF(mark(X1), X2, X3) at position [0] we obtained the following new rules:

MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
MARK(if(0, y1, y2)) → A__IF(0, y1, y2)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(s(x0), y1, y2)) → A__IF(s(mark(x0)), y1, y2)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MARK(prod(X1, X2)) → MARK(X1)
A__FACT(X) → MARK(X)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
MARK(if(0, y1, y2)) → A__IF(0, y1, y2)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
A__PROD(s(X), Y) → MARK(Y)
MARK(add(X1, X2)) → MARK(X2)
MARK(prod(X1, X2)) → A__PROD(mark(X1), mark(X2))
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → MARK(X)
MARK(fact(X)) → A__FACT(mark(X))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(s(x0), y1, y2)) → A__IF(s(mark(x0)), y1, y2)
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(p(X)) → MARK(X)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(X), Y) → MARK(X)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(prod(X1, X2)) → MARK(X2)
MARK(p(X)) → A__P(mark(X))
A__ADD(s(X), Y) → MARK(X)
A__P(s(X)) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(true, X, Y) → MARK(X)
A__IF(false, X, Y) → MARK(Y)
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))
MARK(zero(X)) → MARK(X)

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
A__PROD(s(X), Y) → MARK(Y)
MARK(prod(X1, X2)) → A__PROD(mark(X1), mark(X2))
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(p(X)) → MARK(X)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(X)) → A__P(mark(X))
A__P(s(X)) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__ADD(s(X), Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(true, X, Y) → MARK(X)
A__IF(false, X, Y) → MARK(Y)
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))
MARK(zero(X)) → MARK(X)

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(prod(X1, X2)) → A__PROD(mark(X1), mark(X2)) at position [0] we obtained the following new rules:

MARK(prod(false, y1)) → A__PROD(false, mark(y1))
MARK(prod(0, y1)) → A__PROD(0, mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(prod(true, y1)) → A__PROD(true, mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MARK(prod(X1, X2)) → MARK(X1)
A__FACT(X) → MARK(X)
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → MARK(X)
MARK(fact(X)) → A__FACT(mark(X))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X1)
MARK(prod(0, y1)) → A__PROD(0, mark(y1))
MARK(prod(false, y1)) → A__PROD(false, mark(y1))
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(X), Y) → MARK(X)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(prod(X1, X2)) → MARK(X2)
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(p(X)) → A__P(mark(X))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__ADD(s(X), Y) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))
MARK(zero(X)) → MARK(X)
MARK(prod(true, y1)) → A__PROD(true, mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

MARK(prod(X1, X2)) → MARK(X1)
A__FACT(X) → MARK(X)
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
A__PROD(s(X), Y) → MARK(Y)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X1)
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(p(X)) → A__P(mark(X))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__ADD(s(X), Y) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))
MARK(zero(X)) → MARK(X)

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(p(X)) → A__P(mark(X)) at position [0] we obtained the following new rules:

MARK(p(false)) → A__P(false)
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(true)) → A__P(true)
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
MARK(p(0)) → A__P(0)
MARK(p(s(x0))) → A__P(s(mark(x0)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
A__ADD(s(X), Y) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
MARK(prod(X1, X2)) → MARK(X1)
A__FACT(X) → MARK(X)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
MARK(p(false)) → A__P(false)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
MARK(p(0)) → A__P(0)
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(true)) → A__P(true)
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
A__PROD(s(X), Y) → MARK(Y)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(fact(X)) → A__FACT(mark(X))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X1)
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(add(X1, X2)) → A__ADD(mark(X1), mark(X2)) at position [0] we obtained the following new rules:

MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(false, y1)) → A__ADD(false, mark(y1))
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(add(true, y1)) → A__ADD(true, mark(y1))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
MARK(add(true, y1)) → A__ADD(true, mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(add(false, y1)) → A__ADD(false, mark(y1))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(0, y1)) → A__ADD(0, mark(y1))
A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y))
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(p(X)) → MARK(X)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(true, X, Y) → MARK(X)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__PROD(s(X), Y) → A__PROD(mark(X), mark(Y)) at position [0] we obtained the following new rules:

A__PROD(s(0), y1) → A__PROD(0, mark(y1))
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__PROD(s(zero(x0)), y1) → A__PROD(a__zero(mark(x0)), mark(y1))
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
A__PROD(s(true), y1) → A__PROD(true, mark(y1))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__PROD(s(false), y1) → A__PROD(false, mark(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ Narrowing

                                            ↳ QDP

                                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__PROD(s(0), y1) → A__PROD(0, mark(y1))
MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__PROD(s(true), y1) → A__PROD(true, mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__ADD(s(X), Y) → MARK(X)
A__P(s(X)) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
MARK(prod(X1, X2)) → MARK(X1)
A__FACT(X) → MARK(X)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__PROD(s(zero(x0)), y1) → A__PROD(a__zero(mark(x0)), mark(y1))
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__PROD(s(false), y1) → A__PROD(false, mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ Narrowing

                                            ↳ QDP

                                              ↳ DependencyGraphProof

                                                ↳ QDP

                                                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y))
A__ADD(s(X), Y) → MARK(Y)
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(p(X)) → MARK(X)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__ADD(s(X), Y) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__PROD(s(zero(x0)), y1) → A__PROD(a__zero(mark(x0)), mark(y1))
A__ADD(0, X) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(true, X, Y) → MARK(X)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__ADD(s(X), Y) → A__ADD(mark(X), mark(Y)) at position [0] we obtained the following new rules:

A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
A__ADD(s(zero(x0)), y1) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__ADD(s(false), y1) → A__ADD(false, mark(y1))
A__ADD(s(true), y1) → A__ADD(true, mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ Narrowing

                                            ↳ QDP

                                              ↳ DependencyGraphProof

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
MARK(if(X1, X2, X3)) → MARK(X1)
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__P(s(X)) → MARK(X)
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(prod(X1, X2)) → MARK(X1)
A__FACT(X) → MARK(X)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__PROD(s(zero(x0)), y1) → A__PROD(a__zero(mark(x0)), mark(y1))
A__ADD(0, X) → MARK(X)
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(s(X)) → MARK(X)
A__ADD(s(zero(x0)), y1) → A__ADD(a__zero(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
A__ADD(s(false), y1) → A__ADD(false, mark(y1))
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
A__ADD(s(true), y1) → A__ADD(true, mark(y1))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ Narrowing

                                            ↳ QDP

                                              ↳ DependencyGraphProof

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ QDP

                                                          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(p(X)) → MARK(X)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__PROD(s(zero(x0)), y1) → A__PROD(a__zero(mark(x0)), mark(y1))
A__ADD(0, X) → MARK(X)
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(s(X)) → MARK(X)
A__ADD(s(zero(x0)), y1) → A__ADD(a__zero(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(true, X, Y) → MARK(X)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

MARK(p(zero(x0))) → A__P(a__zero(mark(x0)))

The remaining pairs can at least be oriented weakly.

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(p(X)) → MARK(X)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__PROD(s(zero(x0)), y1) → A__PROD(a__zero(mark(x0)), mark(y1))
A__ADD(0, X) → MARK(X)
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(s(X)) → MARK(X)
A__ADD(s(zero(x0)), y1) → A__ADD(a__zero(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(true, X, Y) → MARK(X)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(A__ADD(x₁, x₂)) = 1
POL(A__FACT(x₁)) = 1
POL(A__IF(x₁, x₂, x₃)) = 1
POL(A__P(x₁)) = x₁
POL(A__PROD(x₁, x₂)) = 1
POL(MARK(x₁)) = 1
POL(a__add(x₁, x₂)) = 1
POL(a__fact(x₁)) = 1
POL(a__if(x₁, x₂, x₃)) = 1
POL(a__p(x₁)) = 1
POL(a__prod(x₁, x₂)) = 1
POL(a__zero(x₁)) = 0
POL(add(x₁, x₂)) = 0
POL(fact(x₁)) = 0
POL(false) = 0
POL(if(x₁, x₂, x₃)) = 0
POL(mark(x₁)) = 1
POL(p(x₁)) = 0
POL(prod(x₁, x₂)) = 0
POL(s(x₁)) = 1
POL(true) = 0
POL(zero(x₁)) = 0

The following usable rules [17] were oriented:

a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
mark(zero(X)) → a__zero(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
a__p(s(X)) → mark(X)
a__add(0, X) → mark(X)
a__if(true, X, Y) → mark(X)
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
mark(fact(X)) → a__fact(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
mark(true) → true
mark(0) → 0
a__fact(X) → fact(X)
mark(false) → false
mark(s(X)) → s(mark(X))
a__add(X1, X2) → add(X1, X2)
a__zero(X) → zero(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__p(X) → p(X)
a__prod(X1, X2) → prod(X1, X2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ Narrowing

                                            ↳ QDP

                                              ↳ DependencyGraphProof

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ QDP

                                                          ↳ QDPOrderProof

                                                            ↳ QDP

                                                              ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__PROD(s(zero(x0)), y1) → A__PROD(a__zero(mark(x0)), mark(y1))
A__ADD(0, X) → MARK(X)
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(s(X)) → MARK(X)
A__ADD(s(zero(x0)), y1) → A__ADD(a__zero(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

A__PROD(s(zero(x0)), y1) → A__PROD(a__zero(mark(x0)), mark(y1))
MARK(prod(zero(x0), y1)) → A__PROD(a__zero(mark(x0)), mark(y1))

The remaining pairs can at least be oriented weakly.

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(s(X)) → MARK(X)
A__ADD(s(zero(x0)), y1) → A__ADD(a__zero(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

Used ordering: Polynomial interpretation [25]:

POL(0) = 1
POL(A__ADD(x₁, x₂)) = 1
POL(A__FACT(x₁)) = 1
POL(A__IF(x₁, x₂, x₃)) = 1
POL(A__P(x₁)) = 1
POL(A__PROD(x₁, x₂)) = x₁
POL(MARK(x₁)) = 1
POL(a__add(x₁, x₂)) = x₁
POL(a__fact(x₁)) = 1
POL(a__if(x₁, x₂, x₃)) = 1
POL(a__p(x₁)) = 1
POL(a__prod(x₁, x₂)) = x₁
POL(a__zero(x₁)) = 0
POL(add(x₁, x₂)) = x₁
POL(fact(x₁)) = 0
POL(false) = 0
POL(if(x₁, x₂, x₃)) = 0
POL(mark(x₁)) = 1
POL(p(x₁)) = 0
POL(prod(x₁, x₂)) = 0
POL(s(x₁)) = 1
POL(true) = 0
POL(zero(x₁)) = 0

The following usable rules [17] were oriented:

a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
mark(zero(X)) → a__zero(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
a__p(s(X)) → mark(X)
a__add(0, X) → mark(X)
a__if(true, X, Y) → mark(X)
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
mark(fact(X)) → a__fact(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
mark(true) → true
mark(0) → 0
a__fact(X) → fact(X)
mark(false) → false
mark(s(X)) → s(mark(X))
a__add(X1, X2) → add(X1, X2)
a__zero(X) → zero(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__p(X) → p(X)
a__prod(X1, X2) → prod(X1, X2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ Narrowing

                                            ↳ QDP

                                              ↳ DependencyGraphProof

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ QDP

                                                          ↳ QDPOrderProof

                                                            ↳ QDP

                                                              ↳ QDPOrderProof

                                                                ↳ QDP

                                                                  ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(p(X)) → MARK(X)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(s(X)) → MARK(X)
A__ADD(s(zero(x0)), y1) → A__ADD(a__zero(mark(x0)), mark(y1))
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(true, X, Y) → MARK(X)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

MARK(add(zero(x0), y1)) → A__ADD(a__zero(mark(x0)), mark(y1))
A__ADD(s(zero(x0)), y1) → A__ADD(a__zero(mark(x0)), mark(y1))

The remaining pairs can at least be oriented weakly.

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
MARK(p(X)) → MARK(X)
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
A__IF(true, X, Y) → MARK(X)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

Used ordering: Polynomial interpretation [25]:

POL(0) = 1
POL(A__ADD(x₁, x₂)) = x₁
POL(A__FACT(x₁)) = 1
POL(A__IF(x₁, x₂, x₃)) = 1
POL(A__P(x₁)) = 1
POL(A__PROD(x₁, x₂)) = 1
POL(MARK(x₁)) = 1
POL(a__add(x₁, x₂)) = x₁
POL(a__fact(x₁)) = 1
POL(a__if(x₁, x₂, x₃)) = 1
POL(a__p(x₁)) = 1
POL(a__prod(x₁, x₂)) = x₁
POL(a__zero(x₁)) = 0
POL(add(x₁, x₂)) = 0
POL(fact(x₁)) = 0
POL(false) = 0
POL(if(x₁, x₂, x₃)) = 0
POL(mark(x₁)) = 1
POL(p(x₁)) = 1
POL(prod(x₁, x₂)) = 0
POL(s(x₁)) = 1
POL(true) = 0
POL(zero(x₁)) = 0

The following usable rules [17] were oriented:

a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
mark(zero(X)) → a__zero(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
a__p(s(X)) → mark(X)
a__add(0, X) → mark(X)
a__if(true, X, Y) → mark(X)
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
mark(fact(X)) → a__fact(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
mark(true) → true
mark(0) → 0
a__fact(X) → fact(X)
mark(false) → false
mark(s(X)) → s(mark(X))
a__add(X1, X2) → add(X1, X2)
a__zero(X) → zero(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__p(X) → p(X)
a__prod(X1, X2) → prod(X1, X2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ Narrowing

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ QDP

                  ↳ Narrowing

                    ↳ QDP

                      ↳ DependencyGraphProof

                        ↳ QDP

                          ↳ Narrowing

                            ↳ QDP

                              ↳ DependencyGraphProof

                                ↳ QDP

                                  ↳ Narrowing

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ Narrowing

                                            ↳ QDP

                                              ↳ DependencyGraphProof

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ QDP

                                                          ↳ QDPOrderProof

                                                            ↳ QDP

                                                              ↳ QDPOrderProof

                                                                ↳ QDP

                                                                  ↳ QDPOrderProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MARK(add(if(x0, x1, x2), y1)) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
MARK(prod(if(x0, x1, x2), y1)) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(Y)
MARK(if(if(x0, x1, x2), y1, y2)) → A__IF(a__if(mark(x0), x1, x2), y1, y2)
MARK(fact(X)) → A__FACT(mark(X))
MARK(prod(p(x0), y1)) → A__PROD(a__p(mark(x0)), mark(y1))
A__ADD(s(add(x0, x1)), y1) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(prod(s(x0), y1)) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(X), Y) → MARK(Y)
A__PROD(s(add(x0, x1)), y1) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
MARK(if(prod(x0, x1), y1, y2)) → A__IF(a__prod(mark(x0), mark(x1)), y1, y2)
MARK(if(X1, X2, X3)) → MARK(X1)
A__ADD(s(0), y1) → A__ADD(0, mark(y1))
MARK(if(true, y1, y2)) → A__IF(true, y1, y2)
MARK(add(0, y1)) → A__ADD(0, mark(y1))
MARK(add(s(x0), y1)) → A__ADD(s(mark(x0)), mark(y1))
MARK(p(X)) → MARK(X)
MARK(if(add(x0, x1), y1, y2)) → A__IF(a__add(mark(x0), mark(x1)), y1, y2)
A__PROD(s(prod(x0, x1)), y1) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
MARK(if(false, y1, y2)) → A__IF(false, y1, y2)
A__ADD(s(p(x0)), y1) → A__ADD(a__p(mark(x0)), mark(y1))
A__FACT(X) → A__IF(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
MARK(p(add(x0, x1))) → A__P(a__add(mark(x0), mark(x1)))
MARK(add(add(x0, x1), y1)) → A__ADD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(X), Y) → A__ADD(mark(Y), a__prod(mark(X), mark(Y)))
A__P(s(X)) → MARK(X)
A__ADD(s(X), Y) → MARK(X)
MARK(p(p(x0))) → A__P(a__p(mark(x0)))
A__PROD(s(if(x0, x1, x2)), y1) → A__PROD(a__if(mark(x0), x1, x2), mark(y1))
MARK(add(p(x0), y1)) → A__ADD(a__p(mark(x0)), mark(y1))
A__IF(false, X, Y) → MARK(Y)
MARK(prod(add(x0, x1), y1)) → A__PROD(a__add(mark(x0), mark(x1)), mark(y1))
A__PROD(s(fact(x0)), y1) → A__PROD(a__fact(mark(x0)), mark(y1))
A__PROD(s(p(x0)), y1) → A__PROD(a__p(mark(x0)), mark(y1))
MARK(zero(X)) → MARK(X)
MARK(p(s(x0))) → A__P(s(mark(x0)))
A__ADD(s(prod(x0, x1)), y1) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))
A__FACT(X) → MARK(X)
MARK(prod(X1, X2)) → MARK(X1)
MARK(if(p(x0), y1, y2)) → A__IF(a__p(mark(x0)), y1, y2)
A__ADD(0, X) → MARK(X)
A__ADD(s(fact(x0)), y1) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(s(X)) → MARK(X)
MARK(add(X1, X2)) → MARK(X2)
MARK(fact(X)) → MARK(X)
MARK(p(fact(x0))) → A__P(a__fact(mark(x0)))
MARK(if(zero(x0), y1, y2)) → A__IF(a__zero(mark(x0)), y1, y2)
MARK(add(X1, X2)) → MARK(X1)
A__PROD(s(s(x0)), y1) → A__PROD(s(mark(x0)), mark(y1))
A__ADD(s(if(x0, x1, x2)), y1) → A__ADD(a__if(mark(x0), x1, x2), mark(y1))
A__PROD(s(X), Y) → MARK(X)
MARK(prod(X1, X2)) → MARK(X2)
A__ADD(s(s(x0)), y1) → A__ADD(s(mark(x0)), mark(y1))
MARK(prod(fact(x0), y1)) → A__PROD(a__fact(mark(x0)), mark(y1))
MARK(prod(prod(x0, x1), y1)) → A__PROD(a__prod(mark(x0), mark(x1)), mark(y1))
A__IF(true, X, Y) → MARK(X)
MARK(if(fact(x0), y1, y2)) → A__IF(a__fact(mark(x0)), y1, y2)
MARK(add(fact(x0), y1)) → A__ADD(a__fact(mark(x0)), mark(y1))
MARK(p(prod(x0, x1))) → A__P(a__prod(mark(x0), mark(x1)))
MARK(p(if(x0, x1, x2))) → A__P(a__if(mark(x0), x1, x2))
MARK(add(prod(x0, x1), y1)) → A__ADD(a__prod(mark(x0), mark(x1)), mark(y1))

The TRS R consists of the following rules:

a__fact(X) → a__if(a__zero(mark(X)), s(0), prod(X, fact(p(X))))
a__add(0, X) → mark(X)
a__add(s(X), Y) → s(a__add(mark(X), mark(Y)))
a__prod(0, X) → 0
a__prod(s(X), Y) → a__add(mark(Y), a__prod(mark(X), mark(Y)))
a__if(true, X, Y) → mark(X)
a__if(false, X, Y) → mark(Y)
a__zero(0) → true
a__zero(s(X)) → false
a__p(s(X)) → mark(X)
mark(fact(X)) → a__fact(mark(X))
mark(if(X1, X2, X3)) → a__if(mark(X1), X2, X3)
mark(zero(X)) → a__zero(mark(X))
mark(prod(X1, X2)) → a__prod(mark(X1), mark(X2))
mark(p(X)) → a__p(mark(X))
mark(add(X1, X2)) → a__add(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(0) → 0
mark(true) → true
mark(false) → false
a__fact(X) → fact(X)
a__if(X1, X2, X3) → if(X1, X2, X3)
a__zero(X) → zero(X)
a__prod(X1, X2) → prod(X1, X2)
a__p(X) → p(X)
a__add(X1, X2) → add(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.